/* The file is saved in UTF-8 codepage.
 * Check: «Stereotype», Section mark-§, Copyright-©, Alpha-α, Beta-β, Smile-☺
 */
package cz.pecinovsky.english.lootp._125_;


import cz.pecinovsky.english.lootp._000_.Run;

import cz.pecinovsky.english.lootp.manager.Mover;


import cz.pecinovsky.english.lootp.manager.CanvasManager_Envelope.               CanvasManager;
import cz.pecinovsky.english.lootp._125_.Light_125_133.                          Light;
import cz.pecinovsky.english.lootp._125_.TestUtility_129_133.                    TestUtility;



////////////////////////////////////////////////////////////////////////////////
//%%+  +++++ End of ignored starting test - place for imports +++++
//%I+ =133c
//
//import správce.*;
//%I-
//%I+ >=133z
//
//import cz.pecinovsky.english.lootp.canvasmanager.Mover;
//import cz.pecinovsky.english.lootp.canvasmanager.CanvasManager;
//%I-
//%A+ >=133z

import cz.pecinovsky.english.lootp.utility.NamedColor;
import cz.pecinovsky.english.lootp.utility.IO;
import cz.pecinovsky.english.lootp.utility.Position;
//%A-
//%X+ xxxxx Start of the ovejumped text with declaration of the envelope xxxxx
/*******************************************************************************
 *<pre>
 * Předchozí: Není - Toto_je_nově_definovaná_třída
 *
 * Projekt  018z_02_Tvary
 *  + testBlink()
 *
 * Projekt  019z_11_Správce
 *   ~ Třída převedena do projektu ovládaného správcem plátna
 *</pre>
 */
public class LightTest_125_133
{ static
//%X- ----- End of the ovejumped text with declaration of the envelope -----


/*******************************************************************************
 * Testovací třída {@code LightTest}  slouží ke komplexnímu otestování
 * třídy {@link LightTest}.
 *
 * @author Rudolf PECINOVSKÝ
 * @version 6.03.2017 — 2010-11-08
 */
public class LightTest extends junit.framework.TestCase
{
    private CanvasManager CM;
    private Light light0;
    private Light lightXY;
    private Light lightXYB;
    private Light lightXYP;
    private Light lightXYPB;
    private Light lightXYPBZ;



//== CONSTANT CLASS ATTRIBUTES =================================================
//== VARIABLE CLASS ATTRIBUTES =================================================
//== STATIC CONSTRUCTOR (CLASS INITIALIZER, STATIC INICITALIZING BLOCK) ========
//== CONSTANT INSTANCE ATTRIBUTES ==============================================
//== VARIABLE INSTANCE ATTRIBUTES ==============================================
//== CLASS GETTERS AND SETTERS =================================================
//== OTHER NON-PRIVATE CLASS METHODS ===========================================

//##############################################################################
//== CONSTUCTORS AND FACTORY METHODS ===========================================

    /***************************************************************************
     * Vytvoří test se zadaným názvem.
     *
     * @param name  Název konstruovaného testu
     */
    public LightTest(String name)
    {
        super(name);
    }



//== PREPARATION AND CLEANING THE FIXTURE ======================================

    /***************************************************************************
     * Inicializace předcházející spuštění každého testu a připravující tzv.
     * přípravek (fixture), což je sada objektů, s nimiž budou testy pracovat.
     */
    @Override
    protected void setUp()
    {
        light0    = new Light();
        lightXY   = new Light(50,  50);
        lightXYB  = new Light(100, 100, NamedColor.RED);
        lightXYP  = new Light( 0, 100, 100);
        lightXYPB = new Light(100,   0, 100, NamedColor.BLUE);
        lightXYPBZ= new Light(150, 150, 150, NamedColor.MAGENTA, NamedColor.NO);

        CM = CanvasManager.getInstance();
        CM.add(light0);
        CM.add(lightXY);
        CM.add(lightXYB);
        CM.add(lightXYP);
        CM.add(lightXYPB);
        CM.add(lightXYPBZ);

//%X+ <126
        System.out.println("\n====== Instance v přípravku pro " + this +
                           "\n| CM: "        + CM +
                           "\n| light0:    " + light0 +
                           "\n| lightXY:   " + lightXY +
                           "\n| lightXYB:  " + lightXYB +
                           "\n| lightXYM : " + lightXYP +
                           "\n| lightXYMB: " + lightXYPB +
                           "\n| lightXYMB: " + lightXYPBZ +
                           "\n======");
//%X-
        IO.inform("Lights prepared");
    }


    /***************************************************************************
     * Úklid po testu - tato metoda se spustí po vykonání každého testu.
     */
    @Override
    protected void tearDown()
    {
    }


//== PRIVATE AND AUXILIARY CLASS METHODS =======================================
//== PRIVATE AND AUXILIARY INSTANCE METHODS ====================================
//%I+ <129
//
//    /***************************************************************************
//     * Za pomoci přesouvače plynule prohodí pozice zadaných světel.
//     *
//     * @param s1 První light
//     * @param s2 Druhé light
//     */
//    private void auxSmoothlySwapPositions(Light s1, Light s2)
//    {
//        Mover mover = new Mover(10);
//        Position p1 = s1.getPosition();
//        mover.moveTo(s2.getPosition(), s1);
//        mover.moveTo(p1,             s2);
//    }
//
//
//    /***************************************************************************
//     * Vyzkouší změny pozice a velikosti zadaného světla.
//     *
//     * @param s Testované light
//     */
//    private void auxPositionSize(Light s)
//    {
//        final int ms = 500;
//        s.setPosition(0, 150);
//        IO.pause(ms);
//        s.setModule(150);
//        IO.pause(ms);
//        s.setModule(25);
//        IO.pause(ms);
//        CM.remove(s);
//        IO.pause(ms);
//    }
//
//%I-

    /***************************************************************************
     * Prohodí pozice zadaných světel a nechá zkontrolovat,
     * zda si světla své pozice doopravdy vyměnila.
     *
     * @param s1 První light
     * @param s2 Druhé light
     */
    private void auxSwapPositions(Light s1, Light s2)
    {
        final int ms = 1000;

        s1.switchOff();
        s2.switchOff();
        IO.pause(ms);

        Position p1 = s1.getPosition();
        s1.setPosition(s2.getPosition());
        s2.setPosition(p1);

        IO.pause(ms);
        s1.switchOn();
        s2.switchOn();

        IO.pause(ms);
    }

//%I+ >126 <129
//
//    /***************************************************************************
//     * Prohodí pozice zadaných světel a nechá zkontrolovat,
//     * zda si světla své pozice doopravdy vyměnila.
//     *
//     * @param s1 První light
//     * @param s2 Druhý light
//     */
//    private void auxSwapPositionsWithCheck(Light s1, Light s2)
//    {
//        Position p1 = s1.getPosition();
//        Position p2 = s2.getPosition();
//
//        System.out.println("Výchozí: " + p1 + " <--> " + p2);
//        auxSwapPositions(s1, s2);
//        System.out.println("Cílová:  " + s1.getPosition() +
//                              " <--> " + s2.getPosition() + "\n");
//
//        assertEquals(p1, s2.getPosition());
//        assertEquals(p2, s1.getPosition());
//    }
//
//%I-


//== EMBEDDED TYPES AND INNER CLASSES ==========================================
//== THE TESTS =================================================================
//
//     /***************************************************************************
//      *
//      */
//     public void testXXX()
//     {
//     }


    public void testBlink()
    {
        light0    .switchOff();
        lightXY   .switchOff();
        lightXYB  .switchOff();
        lightXYP  .switchOff();
        lightXYPB .switchOff();
        lightXYPBZ.switchOff();
        IO.pause(500);
        light0    .blink();
        lightXY   .blink();
        lightXYB  .blink();
        lightXYP  .blink();
        lightXYPB .blink();
        lightXYPBZ.blink();
        IO.pause(500);
        light0    .switchOn();
        lightXY   .switchOn();
        lightXYB  .switchOn();
        lightXYP  .switchOn();
        lightXYPB .switchOn();
        lightXYPBZ.switchOn();
    }

//%I+ <129
//
//    public void testSmoothlySwapPositions()
//    {
//        auxSmoothlySwapPositions(light0,   lightXYPB);
//        auxSmoothlySwapPositions(lightXYB, lightXYP);
//        auxSmoothlySwapPositions(lightXYP, light0);
//    }
//
//%I-

    public void testSmoothMovement()
    {
        Mover p = new Mover(10);
        p.moveTo(200,   0, light0);
        p.moveTo(200,  50, lightXY);
        p.moveTo(  0,   0, lightXYPBZ);
        p.moveTo(200, 100, lightXYPB);
        p.moveTo(150,   0, lightXYB);
        p.moveTo(  0, 150, lightXYP);
    }


    public void testPositionSize()
    {
//%I+ <129
//        auxPositionSize(lightXYPBZ);
//        auxPositionSize(lightXYPB);
//        auxPositionSize(lightXYP);
//        auxPositionSize(lightXYB);
//        auxPositionSize(lightXY);
//        auxPositionSize(light0);
//%I-
//%X+ <129
        Position sem = new Position(0, 150);
        int small = 25;
        int big   = 150;

        TestUtility.positionSize(lightXYPBZ, sem, small, big);
        TestUtility.positionSize(lightXYPB,  sem, small, big);
        TestUtility.positionSize(lightXYP,   sem, small, big);
        TestUtility.positionSize(lightXYB,   sem, small, big);
        TestUtility.positionSize(lightXY,    sem, small, big);
        TestUtility.positionSize(light0,     sem, small, big);
//%X-
    }


    public void testGetColor()
    {
        assertEquals(NamedColor.BLUE, lightXYPB.getColor());
        assertEquals(NamedColor.BLUE, light0.getColor());
    }


    public void testSwapPositions()
    {
        auxSwapPositions(light0,   lightXYPB);
        auxSwapPositions(lightXYB, lightXYP);
        auxSwapPositions(lightXYP, light0);
    }
//%X+ <126


    public void testSwapPositionsWithCheck()
    {
//%X-
//%I+ >126 <129
//        auxSwapPositionsWithCheck(light0,   lightXYPB);
//        auxSwapPositionsWithCheck(lightXYB, lightXYP);
//        auxSwapPositionsWithCheck(lightXYP, light0);
//%I-
//%X+ <129
        TestUtility.swapPositionsWithCheck(light0,   lightXYPB);
        TestUtility.swapPositionsWithCheck(lightXYB, lightXYP);
        TestUtility.swapPositionsWithCheck(lightXYP, light0);
//%X-
//%X+ <126
    }
//%X-
//%X+
     /** */
     public void testFixture() {}
//%X-
}

//%%- ---- Start of the ovejumped text with closing of the envelope ----
//== TESTING CLASSES AND METHODS ===============================================
    private LightTest_125_133() {}

    /***************************************************************************
     * Třída, jejíž instance má na starosti úklid mezi jednotlivými testy,
     * který není možno zakomponovat do metody {@code tearDown()},
     * dokud nebudou studenti umět programovat.
     */
    private static class TearDown implements Run.ITD
    {
        /** {@inheritDoc} */
        @Override
        public void cleanUp()
        {
//            Canvas.clearCanvas();
            CanvasManager.getInstance().removeAll();
        }
    }


    /***************************************************************************
     * Test method.
     */
    public static void test()
    {
//        junit.textui.TestRunner.run(suite());
//        junit.textui.TestRunner.run(new Třída("test"));
        Run.tests(LightTest.class,
                new TearDown(),
//                "testFixture",
//                "testBlink",
                "testPositionSize",
//                "testSmoothMovement",
//                "testSwapPositions",
                "testSwapPositionsWithCheck",
//                "testSmoothlySwapPositions",
                "");
        System.exit(0);
    }
    /** @param args Parametry příkazového řádku - nepoužívané. */
    public static void main(String[] args)  {  test();  }
}
